/**
 * 翻译文件验证脚本
 * 
 * 此脚本用于验证所有翻译文件的JSON语法和结构完整性
 * 使用方法：node scripts/validate-locales.js
 */
const fs = require('fs');
const path = require('path');

// 定义本地化文件路径
const LOCALES_DIR = path.join(__dirname, '../public/locales');
const SUPPORTED_LANGUAGES = ['en', 'zh'];

// 验证单个JSON文件
function validateJsonFile(filePath) {
  console.log(`正在验证: ${filePath}`);
  try {
    // 读取文件内容
    const fileContent = fs.readFileSync(filePath, 'utf8');
    
    // 尝试解析JSON
    const jsonContent = JSON.parse(fileContent);
    
    // 检查是否是对象
    if (typeof jsonContent !== 'object' || jsonContent === null) {
      throw new Error('翻译文件必须是JSON对象');
    }
    
    console.log(`✅ ${filePath} - 验证通过`);
    return { valid: true, content: jsonContent };
  } catch (error) {
    console.error(`❌ ${filePath} - 验证失败: ${error.message}`);
    if (error instanceof SyntaxError) {
      // 定位JSON语法错误的行号
      const lines = fs.readFileSync(filePath, 'utf8').split('\n');
      const errorMatch = error.message.match(/at position (\d+)/);
      if (errorMatch) {
        const position = parseInt(errorMatch[1], 10);
        let lineNo = 0;
        let charCount = 0;
        for (let i = 0; i < lines.length; i++) {
          charCount += lines[i].length + 1; // +1 for newline character
          if (charCount >= position) {
            lineNo = i + 1;
            break;
          }
        }
        console.error(`   语法错误可能在第 ${lineNo} 行附近`);
        // 显示出错行前后的内容
        const startLine = Math.max(0, lineNo - 3);
        const endLine = Math.min(lines.length, lineNo + 2);
        for (let i = startLine; i < endLine; i++) {
          const marker = i + 1 === lineNo ? '> ' : '  ';
          console.error(`   ${marker}${i + 1}: ${lines[i]}`);
        }
      }
    }
    return { valid: false, error: error.message };
  }
}

// 比较两个翻译文件的键结构
function compareTranslations(baseTranslation, compareTranslation, language) {
  const missingKeys = [];
  
  function checkKeys(base, compare, prefix = '') {
    for (const key in base) {
      const fullKey = prefix ? `${prefix}.${key}` : key;
      
      if (typeof base[key] === 'object' && base[key] !== null && !Array.isArray(base[key])) {
        // 如果是对象，递归检查
        if (!compare[key] || typeof compare[key] !== 'object' || Array.isArray(compare[key])) {
          missingKeys.push({ key: fullKey, type: 'missing-object' });
        } else {
          checkKeys(base[key], compare[key], fullKey);
        }
      } else {
        // 如果是简单值，检查键是否存在
        if (!(key in compare)) {
          missingKeys.push({ key: fullKey, type: 'missing-key' });
        }
      }
    }
  }
  
  checkKeys(baseTranslation, compareTranslation);
  
  if (missingKeys.length > 0) {
    console.error(`\n⚠️ ${language}翻译文件缺少以下键:`);
    missingKeys.forEach(item => {
      console.error(`   - ${item.key} (${item.type === 'missing-object' ? '缺少对象结构' : '缺少键'})`);
    });
    return false;
  }
  
  return true;
}

// 主函数
function validateLocales() {
  console.log('开始验证翻译文件...\n');
  
  let allValid = true;
  const translations = {};
  
  // 检查本地化目录是否存在
  if (!fs.existsSync(LOCALES_DIR)) {
    console.error(`❌ 本地化目录不存在: ${LOCALES_DIR}`);
    return false;
  }
  
  // 验证所有支持的语言
  for (const lang of SUPPORTED_LANGUAGES) {
    const langDir = path.join(LOCALES_DIR, lang);
    
    // 检查语言目录是否存在
    if (!fs.existsSync(langDir)) {
      console.error(`❌ 语言目录不存在: ${langDir}`);
      allValid = false;
      continue;
    }
    
    const translationFile = path.join(langDir, 'translation.json');
    
    // 检查翻译文件是否存在
    if (!fs.existsSync(translationFile)) {
      console.error(`❌ 翻译文件不存在: ${translationFile}`);
      allValid = false;
      continue;
    }
    
    // 验证JSON文件
    const result = validateJsonFile(translationFile);
    if (!result.valid) {
      allValid = false;
    } else {
      translations[lang] = result.content;
    }
  }
  
  // 如果所有文件都有效，比较翻译键结构
  if (allValid && SUPPORTED_LANGUAGES.length > 1 && translations.en) {
    console.log('\n开始比较翻译键结构...');
    
    const baseTranslation = translations.en;
    
    for (const lang of SUPPORTED_LANGUAGES) {
      if (lang === 'en') continue; // 跳过基准语言
      
      console.log(`\n比较 ${lang} 与 en 的翻译键结构:`);
      const isComplete = compareTranslations(baseTranslation, translations[lang], lang);
      if (!isComplete) {
        allValid = false;
      }
    }
  }
  
  console.log('\n验证结果:');
  if (allValid) {
    console.log('✅ 所有翻译文件验证通过!');
  } else {
    console.error('❌ 部分翻译文件验证失败，请修复上述问题。');
  }
  
  return allValid;
}

// 执行验证
const isValid = validateLocales();

// 设置退出码
process.exit(isValid ? 0 : 1); 